package com.cms.jy.draft.util;

import cn.hutool.core.bean.BeanUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.cms.jy.utils.LyricFenjingUtil;
import com.cms.jy.draft.constant.*;
import com.cms.jy.draft.entity.*;
import com.google.gson.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.EncoderException;
import org.apache.commons.lang.StringUtils;
import ws.schild.jave.MultimediaObject;
import ws.schild.jave.info.MultimediaInfo;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;

@Slf4j
public class AddUtil {

    /**
     * 添加文字（带入场和出场动画）
     * @param draftContent 草稿内容
     * @param textContent 文本内容
     * @param fontName 字体
     * @param fontSize 字体大小
     * @param textIntro 入场动画元数据
     * @param textOutro 出场动画元数据
     * @param starttime 开始时间
     * @param duration 持续时间
     * @param transformX X
     * @param transformY Y
     * @param scaleX 缩放X
     * @param scaleY 缩放Y
     * @param showShade 是否显示阴影
     * @param trackName 轨道名称
     * @param showBold 是否显示粗体
     */
    public static void addTextWithAnimations(DraftContent draftContent, String textContent, Effect fontName, double fontSize,
                                             AnimationMeta textIntro, AnimationMeta textOutro, long starttime, long duration,
                                             int transformX, int transformY, double scaleX, double scaleY,
                                             boolean showShade, String trackName, boolean showBold) {
        if (duration == 0) {
            duration = 1000000;
        }
        if (StringUtils.isBlank(trackName)) {
            trackName = "";
        }
        // 使用ElementAdder创建带有正确格式内容的文字对象
        Text text = ElementAdder.createTextWithContent(textContent, fontName, fontSize, showShade, showBold);
        
        // 使用预定义的入场和出场动画
        ElementAdder.addPredefinedTextAnimations(
            text,
                textIntro,  // 使用预定义的入场动画
                textOutro  // 使用预定义的出场动画
        );
        
        // 使用ElementAdder添加文字到草稿
        ElementAdder.addTextToDraft(draftContent, text);
        
        // 创建材料动画对象并添加动画
        MaterialAnimation materialAnimation = new MaterialAnimation();
        String materialAnimationId = java.util.UUID.randomUUID().toString();
        materialAnimation.setId(materialAnimationId);
        materialAnimation.setType("text_animation"); // 修改为正确的类型
        materialAnimation.setMulti_language_current("none");
        
        // 添加入场和出场动画到材料动画
        java.util.List<Animation> animations = new java.util.ArrayList<>();
        // 获取文字的入场动画
        if (text.getAnimations() != null && text.getAnimations().getInAnimation() != null) {
            animations.add(text.getAnimations().getInAnimation());
        }
        // 获取文字的出场动画
        if (text.getAnimations() != null && text.getAnimations().getOutAnimation() != null) {
            animations.add(text.getAnimations().getOutAnimation());
        }
        materialAnimation.setAnimations(animations);
        
        // 添加材料动画到草稿
        ElementAdder.addMaterialAnimationToDraft(draftContent, materialAnimation);
        
        // 为文字添加轨道和片段（这里会自动处理动画引用）
        ElementAdder.addTextTrackAndSegment(draftContent, text, starttime, duration, materialAnimationId,
                (double) transformX/ Config.SCREEN_WIDTH, (double) transformY/Config.SCREEN_HEIGHT, scaleX, scaleY, trackName); // 显示3秒
    }

    /**
     * 将时:分:秒:帧格式的时间转换为毫秒
     * @param timeCode 时间码格式 "HH:MM:SS:FF"
     * @param frameRate 帧率，默认30fps
     * @return 毫秒数
     */
    public static long timeCodeToMillis(String timeCode, double frameRate) {
        String[] parts = timeCode.split(":");
        if (parts.length != 4) {
            throw new IllegalArgumentException("Invalid time code format. Expected HH:MM:SS:FF");
        }

        int hours = Integer.parseInt(parts[0]);
        int minutes = Integer.parseInt(parts[1]);
        int seconds = Integer.parseInt(parts[2]);
        int frames = Integer.parseInt(parts[3]);

        // 转换为毫秒
        long totalMillis = hours * 3600000L +  // 小时转毫秒
                minutes * 60000L +  // 分钟转毫秒
                seconds * 1000L +   // 秒转毫秒
                Math.round(frames * 1000.0 / frameRate); // 帧转毫秒

        return totalMillis * 1000;
    }

    public static long duration(String startCode, String endCode, double frameRate) {
        return timeCodeToMillis(endCode, frameRate) - timeCodeToMillis(startCode, frameRate);
    }

    /**
     * 添加视频
     * @param draftContent 草稿内容
     * @param videoPath 视频路径
     * @param trackName 轨道名称
     * @param starttime 开始时间
     * @param duration 持续时间
     * @param intro 入场动画
     * @param outro 出场动画
     * @param transition 转场
     */
    public static void addVideo(DraftContent draftContent, String videoPath, String trackName,
                                long starttime, long duration,long sourceDuration,
                                AnimationMeta intro, AnimationMeta outro, Transition  transition,
                                int transformX, int transformY, double scaleX, double scaleY, double  rotate,
                                double speend, String blendMode, double alpha, KeyframeInput keyframeInput) {
        if (StringUtils.isBlank(trackName)) {
            trackName = "";
        }

        // 使用ElementAdder创建增强版视频对象
        Video video = ElementAdder.createEnhancedVideo(videoPath, duration, Config.SCREEN_WIDTH, Config.SCREEN_HEIGHT);

        // 使用ElementAdder添加视频到草稿
        ElementAdder.addVideoToDraft(draftContent, video);

        Effect blendModeEffect = null;
        if(StringUtils.isNotBlank(blendMode)) {
            blendModeEffect = new Effect();
            BeanUtil.copyProperties(BlendType.lv_se,blendModeEffect);
            blendModeEffect.setType("mix_mode");
            blendModeEffect.setValue(1.0);
            blendModeEffect.setPath("C:/Users/Administrator/AppData/Local/JianyingPro/User Data/Cache/effect/"
                    + blendModeEffect.getEffect_id() + "/" + blendModeEffect.getMd5()); // 设置正确的路径
            blendModeEffect.setId(UUID.randomUUID().toString());
            draftContent.getMaterials().getEffects().add(blendModeEffect);
        }

        // 创建视频出场动画
        MaterialAnimation materialAnimation = new MaterialAnimation();
        String materialAnimationId = java.util.UUID.randomUUID().toString();
        materialAnimation.setId(materialAnimationId);
        materialAnimation.setType("sticker_animation"); // 修改为正确的类型
        materialAnimation.setMulti_language_current("none");

        // 添加出场动画到材料动画
        java.util.List<Animation> animations = new java.util.ArrayList<>();
        // 使用预定义的视频出场动画（向上转出）
        if (outro != null) {
            Animation outAnimation = ElementAdder.createPredefinedVideoOutroAnimation(outro);
            animations.add(outAnimation);
        }
        if (intro != null) {
            // 使用预定义的视频入场动画（向下进场）
            Animation inAnimation = ElementAdder.createPredefinedVideoInroAnimation(intro);
            animations.add(inAnimation);
        }

        materialAnimation.setAnimations(animations);

        // 添加材料动画到草稿
        ElementAdder.addMaterialAnimationToDraft(draftContent, materialAnimation);

        // 添加转场到草稿
        Transition addtransition = null;
        if (transition != null) {
            addtransition = ElementAdder.addTransitionToDraft(draftContent, transition);
        }

        // 为视频添加轨道和片段（带动画ID和转场ID）
        addVideoTrackAndSegmentWithTransition(draftContent, video, starttime, duration, sourceDuration,materialAnimationId,
                addtransition == null ? "" :addtransition.getId(), trackName,
                (double) transformX/ Config.SCREEN_WIDTH, (double) transformY/ Config.SCREEN_WIDTH,
                scaleX, scaleY, rotate, speend, alpha, blendModeEffect == null ? "" : blendModeEffect.getId(), keyframeInput);

        // 输出当前视频元素数量
//        if (draftContent.getMaterials() != null && draftContent.getMaterials().getVideos() != null) {
//            System.out.println("  当前视频元素数量: " + draftContent.getMaterials().getVideos().size());
//        }
    }

    /**
     * 为草稿添加视频轨道和片段（支持动画ID 和转场ID）
     * @param draftContent 草稿内容
     * @param video 视频元素
     * @param start 时间（微秒）
     * @param duration 显示时长（微秒）
     * @param animationId 动画ID
     * @param transitionId 转场ID
     * @param trackName 轨道名称
     */
    public static void addVideoTrackAndSegmentWithTransition(DraftContent draftContent, Video video, long start, long duration,long sourceDuration,
                                                             String animationId, String transitionId, String trackName,
                                                             double transformX, double transformY, double scaleX, double scaleY, double  rotate,
                                                             double speend, double alpha, String blendModeEffectId, KeyframeInput keyframeInput) {
        if (draftContent.getTracks() == null) {
            return;
        }

        // 查找现有的视频轨道或创建新的视频轨道
        Track videoTrack = null;
        for (Track track : draftContent.getTracks()) {
            if (trackName.equals(track.getName())) {
                videoTrack = track;
                break;
            }
        }

        Speed  speed = new Speed();
        speed.setId(java.util.UUID.randomUUID().toString());
        speed.setMode(0);
        speed.setSpeed(speend);
        speed.setType("speed");
        draftContent.getMaterials().getSpeeds().add(speed);

        // 如果没有找到视频轨道，则创建一个新的
        if (videoTrack == null) {
            videoTrack = new Track();
            videoTrack.setId(java.util.UUID.randomUUID().toString());
            videoTrack.setType("video");
            videoTrack.setAttribute(0);
            videoTrack.setFlag(0);
            videoTrack.setIs_default_name(true);
            videoTrack.setName(trackName);
            videoTrack.setSegments(new java.util.ArrayList<>());
            draftContent.getTracks().add(videoTrack);
        }

        // 创建视频片段
        Segment segment = new Segment();
        segment.setSource_timerange(new TimeRange());
        segment.getSource_timerange().setStart(0);
        segment.getSource_timerange().setDuration(sourceDuration);
        segment.setId(java.util.UUID.randomUUID().toString());
        segment.setMaterial_id(video.getId());
        segment.setTarget_timerange(new TimeRange());
        segment.getTarget_timerange().setStart(start);
        segment.getTarget_timerange().setDuration(duration);
        segment.setRender_index(0); // 设置渲染索引
        segment.setTrack_render_index(0); // 设置轨道渲染索引
        segment.setTrack_attribute(0);
        segment.setVisible(true);
        segment.setCartoon(false);
        segment.setEnable_adjust(true);
        segment.setEnable_color_curves(true);
        segment.setEnable_color_wheels(true);
        segment.setEnable_lut(true);
        segment.setEnable_smart_color_adjust(false);
        segment.setIs_placeholder(false);
        segment.setIs_tone_modify(false);
        segment.setLast_nonzero_volume(1.0);
        segment.setReverse(false);
        segment.setTemplate_scene("default");
        segment.setTemplate_id("");
        segment.setVolume(0.0);
        segment.setSpeed(speend);
        segment.setKeyframe_refs(new java.util.ArrayList<>());

        if (keyframeInput != null) {
            // 创建位置关键帧动画
            List<Keyframe> positionKeyframes = new ArrayList<>();

            Keyframe posXKeyframe = ElementAdder.createPositionXKeyframe(keyframeInput.getDurationX(), keyframeInput.getX()); // 开始位置
            positionKeyframes.add(posXKeyframe);

            Keyframe posYKeyframe = ElementAdder.createPositionYKeyframe(keyframeInput.getDurationY(), keyframeInput.getY());
            positionKeyframes.add(posYKeyframe);

            Keyframe scaleXKeyframe = ElementAdder.createScaleXKeyframe(keyframeInput.getDurationScaleX(), keyframeInput.getScaleY());
            positionKeyframes.add(scaleXKeyframe);

            Keyframe scaleYKeyframe = ElementAdder.createScaleYKeyframe(keyframeInput.getDurationScaleY(), keyframeInput.getScaleY());
            positionKeyframes.add(scaleYKeyframe);

            Keyframe rotationKeyframe = ElementAdder.createRotationKeyframe(keyframeInput.getDurationRotation(), keyframeInput.getRotation());
            positionKeyframes.add(rotationKeyframe);

            Keyframe alphaKeyframe = ElementAdder.createAlphaKeyframe(keyframeInput.getDurationAlpha(), keyframeInput.getAlpha());
            positionKeyframes.add(alphaKeyframe);
            segment.setCommon_keyframes(positionKeyframes);
        } else {
            segment.setCommon_keyframes(new java.util.ArrayList<>());
        }



        // 设置extra_material_refs，包含动画ID和转场ID
        java.util.List<String> extraMaterialRefs = new java.util.ArrayList<>();
        if (animationId != null) {
            extraMaterialRefs.add(animationId);
        }
        if (transitionId != null) {
            extraMaterialRefs.add(transitionId);
        }
        if (blendModeEffectId != null) {
            extraMaterialRefs.add(blendModeEffectId);
        }
        extraMaterialRefs.add(speed.getId());
        segment.setExtra_material_refs(extraMaterialRefs);

        // 添加clip对象配置，这是视频播放必需的
        Clip clip = new Clip();
        clip.setAlpha(alpha);
        clip.setFlip(new Flip());
        clip.getFlip().setHorizontal(false);
        clip.getFlip().setVertical(false);
        clip.setRotation(rotate);
        clip.setScale(new Scale());
        clip.getScale().setX(scaleX);
        clip.getScale().setY(scaleY);
        clip.setTransform(new Transform());
        clip.getTransform().setX(transformX);
        clip.getTransform().setY(transformY);
        segment.setClip(clip);

        // 将片段添加到轨道
        videoTrack.getSegments().add(segment);
    }

    /**
     * 基于模板创建草稿
     * @param OUTPUT_BASE_PATH 输出基础路径
     * @param TEMPLATE_PATH 模板路径
     * @return
     * @throws IOException
     */
    public static String createDraftFromTemplate(String OUTPUT_BASE_PATH, String TEMPLATE_PATH) throws IOException {
        // 生成唯一的草稿ID
        String draftId = "draft-" + System.currentTimeMillis();
        String draftPath = OUTPUT_BASE_PATH + "/" + draftId;

        // 使用DraftCreator工具类创建草稿（复制模板目录中的所有文件和文件夹）
        DraftCreator.createDraftFromTemplate(TEMPLATE_PATH, draftPath);

        return draftPath;
    }

    /**
     * 从模板读取草稿内容
     * @param TEMPLATE_PATH 模板路径
     * @return
     * @throws IOException IO异常
     */
    public static DraftContent readDraftContentFromTemplate(String TEMPLATE_PATH) throws IOException {
        String templateContentPath = TEMPLATE_PATH + "/draft_content.json";
        // 使用UTF-8编码读取模板文件
        String content = new String(Files.readAllBytes(Paths.get(templateContentPath)), StandardCharsets.UTF_8);

        // 使用Gson从JSON字符串创建DraftContent对象，使用下划线命名策略
        Gson gson = new GsonBuilder()
                .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
                .create();
        DraftContent draftContent = gson.fromJson(content, DraftContent.class);

        return draftContent;
    }

    /**
     * 添加特效
     * @param draftContent 草稿内容
     * @param effectConstant 特效常量
     * @param starttime 特效开始时间
     * @param duration 特效持续时间
     */
    public static void addEffect(DraftContent draftContent, Effect effectConstant,long starttime, long duration) {
        try {

            if (effectConstant == null) {
                System.out.println("  effect is null");
                return;
            }


            // 创建一个新的VideoEffect实例，避免修改常量对象
            VideoEffect videoEffect = new VideoEffect();

            // 复制常量中的属性到VideoEffect实例
            videoEffect.setCategory_id("39654");
            videoEffect.setCategory_name("热门");
            videoEffect.setName(effectConstant.getName());
            videoEffect.setResource_id(effectConstant.getResource_id());
            videoEffect.setEffect_id(effectConstant.getEffect_id());
            videoEffect.setPath("C:/Users/Administrator/AppData/Local/JianyingPro/User Data/Cache/effect/"
                    + effectConstant.getEffect_id() + "/" + effectConstant.getMd5()); // 设置正确的路径
            videoEffect.setPlatform("all");
            videoEffect.setType("video_effect"); // 设置正确的类型
            videoEffect.setValue(1.0); // 设置默认值
            videoEffect.setVersion(""); // 设置版本为空字符串
            videoEffect.setApply_target_type(2); // 设置应用目标类型
            videoEffect.setRender_index(0); // 设置渲染索引
            videoEffect.setTrack_render_index(0); // 设置轨道渲染索引
            videoEffect.setSource_platform(0); // 设置来源平台
            videoEffect.setCategory_id("heycan_search_special_effect"); // 设置正确的分类ID
            videoEffect.setCategory_name("heycan_search_special_effect"); // 设置正确的分类名称
            videoEffect.setAlgorithm_artifact_path(""); // 设置算法产物路径
            videoEffect.setFormula_id(""); // 设置公式ID
            videoEffect.setRequest_id(""); // 设置请求ID（与copy目录一致）
            videoEffect.setApply_time_range(null); // 设置应用时间范围
            videoEffect.setTime_range(null); // 设置时间范围
            videoEffect.setCommon_keyframes(new java.util.ArrayList<>()); // 设置公共关键帧
            videoEffect.setDisable_effect_faces(new java.util.ArrayList<>()); // 设置禁用人脸特效

            // 复制调整参数（使用正确的字段名）
            if (effectConstant.getAdjust_params() != null) {
                java.util.List<EffectParam> params = new java.util.ArrayList<>();
                for (EffectParam param : effectConstant.getAdjust_params()) {
                    // 创建新的EffectParam对象，使用正确的字段名
                    EffectParam newParam = new EffectParam();
                    newParam.setName(param.getName());
                    newParam.setValue(param.getValue());
                    newParam.setDefaultValue(param.getValue()); // 使用正确的setter方法
                    // 注意：不设置minValue和maxValue，以保持与copy目录一致
                    params.add(newParam);
                }
                videoEffect.setAdjust_params(params);
            }

            // 为特效生成唯一ID，使用与copy目录下相同的ID
            videoEffect.setId(UUID.randomUUID().toString());

            // 使用ElementAdder添加视频特效到草稿
            ElementAdder.addVideoEffectToDraft(draftContent, videoEffect);

            // 添加特效轨道和片段
            ElementAdder.addEffectTrackAndSegment(draftContent, videoEffect, starttime, duration);

        } catch (Exception e) {
            System.err.println("  添加特效时出现错误: " + e.getMessage());
            e.printStackTrace();
        }
    }

    /**
     * 添加音频
     * @param draftContent 草稿内容
     */
    public static void addAudio(DraftContent draftContent, String audioPath, long starttime, long duration, Double volume, String trickName) {

        if (StringUtils.isBlank(trickName)) {
            trickName = "";
        }

        // 使用ElementAdder创建音频对象
        Audio audio = ElementAdder.createAudio(audioPath, duration);
        String audioName = Paths.get(audioPath).getFileName().toString();

        // 添加淡入淡出效果
        AudioFadeEffect fadeEffect = new AudioFadeEffect();
        fadeEffect.setFadeInDuration(0); // 1秒淡入
        fadeEffect.setFadeOutDuration(0); // 1秒淡出
        fadeEffect.setFadeType(0);
        audio.setFadeEffect(fadeEffect);

        // 设置音频的其他属性，使其与草稿中的配置一致
        audio.setId(UUID.randomUUID().toString());
        audio.setApp_id(0);
        audio.setCategory_id("");
        audio.setCategory_name("local");
        audio.setCheck_flag(1);
        audio.setCopyright_limit_type("none");
        audio.setEffect_id("");
        audio.setFormula_id("");
        audio.setIntensifies_path("");
        // 使用Lombok生成的正确setter方法名
        audio.set_ai_clone_tone(false);
        audio.set_text_edit_overdub(false);
        audio.set_ugc(false);
        audio.setLocal_material_id(UUID.randomUUID().toString());
        audio.setMusic_id(UUID.randomUUID().toString());
        audio.setName(audioName);
        audio.setQuery("");
        audio.setRequest_id("");
        audio.setResource_id("");
        audio.setSearch_id("");
        audio.setSource_from("");
        audio.setSource_platform(0);
        audio.setTeam_id("");
        audio.setText_id("");
        audio.setTone_category_id("");
        audio.setTone_category_name("");
        audio.setTone_effect_id("");
        audio.setTone_effect_name("");
        audio.setTone_platform("");
        audio.setTone_second_category_id("");
        audio.setTone_second_category_name("");
        audio.setTone_speaker("");
        audio.setTone_type("");
        audio.setType("extract_music");
        audio.setVideo_id("");
        audio.setWave_points(new java.util.ArrayList<>());

        // 使用ElementAdder添加音频到草稿
        ElementAdder.addAudioToDraft(draftContent, audio);

        // 添加音频轨道和片段
        ElementAdder.addAudioTrackAndSegment(draftContent, audio, starttime, duration, AudioVolumeConverter.dBToLinear(volume), trickName);
    }

    /**
     * 保存草稿
     * @param draftContent 草稿内容
     * @param draftPath 草稿路径
     * @throws IOException IO异常
     */
    public static void saveDraft(DraftContent draftContent, String draftPath) throws IOException {
        // 保存草稿内容到文件
        String contentPath = draftPath + "/draft_content.json";

        // 使用Gson将对象转换为JSON并保存，确保使用UTF-8编码，使用下划线命名策略
        Gson gson = new GsonBuilder()
                .setPrettyPrinting()
                .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
                .create();
        String jsonContent = gson.toJson(draftContent);

        // 在保存之前，确保所有材料动画的类型正确设置
        // 特别是对于文字动画，类型应该是"text_animation"而不是"sticker_animation"
        JsonObject jsonObject = JsonParser.parseString(jsonContent).getAsJsonObject();

        // 检查并修复材料动画类型
        if (jsonObject.has("materials") && !jsonObject.get("materials").isJsonNull()) {
            JsonObject materials = jsonObject.getAsJsonObject("materials");
            if (materials.has("material_animations") && !materials.get("material_animations").isJsonNull()) {
                JsonArray materialAnimations = materials.getAsJsonArray("material_animations");

                // 遍历所有材料动画，修复类型
                for (int i = 0; i < materialAnimations.size(); i++) {
                    JsonObject materialAnimation = materialAnimations.get(i).getAsJsonObject();

                    // 检查是否有动画列表
                    if (materialAnimation.has("animations") && !materialAnimation.get("animations").isJsonNull()) {
                        JsonArray animations = materialAnimation.getAsJsonArray("animations");

                        // 检查动画列表中是否有text类型的动画
                        boolean hasTextAnimation = false;
                        for (int j = 0; j < animations.size(); j++) {
                            JsonObject animation = animations.get(j).getAsJsonObject();
                            if (animation.has("material_type") && animation.get("material_type").getAsString().equals("text")) {
                                hasTextAnimation = true;
                                break;
                            }
                        }

                        // 如果有text类型的动画，确保材料动画类型是"text_animation"
                        if (hasTextAnimation && materialAnimation.has("type")) {
                            materialAnimation.addProperty("type", "text_animation");
                        }
                    }
                }

                // 更新materials中的material_animations
                materials.add("material_animations", materialAnimations);
            }
        }

        // 更新整个对象
        jsonContent = gson.toJson(jsonObject);

        // 使用OutputStreamWriter确保UTF-8编码
        try (OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream(contentPath), StandardCharsets.UTF_8)) {
            writer.write(jsonContent);
        }

        System.out.println("  草稿内容已保存到: " + contentPath);
    }

    public static long getAudioDuration(String filePath) throws EncoderException, ws.schild.jave.EncoderException {
        File source = new File(filePath);
        MultimediaObject multimediaObject = new MultimediaObject(source);
        MultimediaInfo info = multimediaObject.getInfo();

        return info.getDuration() *  1000   ;
    }

    /**
     * 为视频片段添加关键帧动画效果
     * @param draftContent 草稿内容
     * @param segmentId 片段ID
     * @param keyframes 关键帧列表
     */
    public static void addKeyframesToSegment(DraftContent draftContent, String segmentId, List<Keyframe> keyframes) {
        // 查找指定ID的片段
        for (Track track : draftContent.getTracks()) {
            for (Segment segment : track.getSegments()) {
                if (segmentId.equals(segment.getId())) {
                    // 为片段添加所有关键帧
                    for (Keyframe keyframe : keyframes) {
                        ElementAdder.addKeyframeToSegment(segment, keyframe);
                    }
                    return;
                }
            }
        }
    }

}